import base64
import hashlib
import json
import random
import re
import string
import time
from functools import wraps

from captcha.image import ImageCaptcha
from cryptography.fernet import Fernet
from flask import Flask
from flask import jsonify
from flask import request
from flask_cors import CORS
from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity
from flask_mail import Message
from sqlmodel import SQLModel

import config
import emailcaptcha
import namecard
import namecardholder
import namecardholderrecycle
import namecardrecycle
import permission
import settings
import user
import user_permission
from exts import mail
from namecard import NameCard
from namecardholder import NameCardHolder
from user import User

SQLModel.metadata.create_all(settings.engine)

app = Flask(__name__)
cors = CORS(app)#不要修改这个配置，默认是允许所有来源的跨域请求访问所有路由
app.config.from_object(config)
mail.init_app(app)

# 初始化JWTManager
jwt = JWTManager(app)
# 配置JWT密钥和过期时间
app.config['JWT_SECRET_KEY'] = 'your-secret-key'  # 替换为更安全的密钥
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = 86400  # 令牌有效期为24小时
app.config['MAIL_SUPPRESS_SEND'] = False  # 确保不是测试模式
app.config['MAIL_DEBUG'] = True

def check_all_required_fields(data: dict, required_fields: list) -> bool:
    """
    检查字典中是否包含所有必填字段
    :param data: 待检查的字典
    :param required_fields: 必须全部存在的字段列表
    :return: True表示字段齐全，False表示有缺失
    """
    return all(field in data for field in required_fields)

def get_priority_key_value(data: dict, priority_fields: list) -> tuple | None:
    """
    根据优先级顺序返回第一个存在的字段键值对
    :param data: 待检查的字典
    :param priority_fields: 优先级字段列表（按顺序检查）
    :return: 存在则返回 (key, value)，否则返回 None
    """
    for key in priority_fields:
        if key in data:
            return (key, data[key])
    return None

# 加密函数
def encrypt(message: str) -> str:
    """
    加密字符串。

    参数:
        message (str): 需要加密的字符串。

    返回:
        str: 加密后的字符串。
    """
    try:
        fernet = Fernet(settings.SECRET_KEY)
    except Exception as e:
        raise e
    return fernet.encrypt(message.encode()).decode()

def decrypt(encrypted: str) -> str:
    """
    解密字符串。

    参数:
        encrypted (str): 需要解密的字符串。

    返回:
        str: 解密后的字符串。
    """
    try:
        fernet = Fernet(settings.SECRET_KEY)
    except Exception as e:
        raise e
    return fernet.decrypt(encrypted.encode()).decode()

def generate_captcha(period_of_validity_in_seconds: int = 300) -> tuple:
    """
    生成验证码图片和验证码文本。

    参数:
        period_of_validity_in_seconds (int, 可选): 验证码的有效期，默认为300秒。

    返回:
        tuple: 包含验证码图片(base64编码)、验证码ID和验证码文本的元组。
    """
    captcha_text = ''.join(random.choices(string.ascii_uppercase + string.digits, k=4))
    image = ImageCaptcha(width=200, height=80)
    data = image.generate(captcha_text)
    captcha_base64 = base64.b64encode(data.getvalue()).decode('utf-8')
    captcha_expiration = int(time.time()) + period_of_validity_in_seconds
    captcha_token = json.dumps({
        'captcha_text': captcha_text,
        'captcha_expiration': captcha_expiration
    })
    captcha_id = encrypt(captcha_token)
    return captcha_base64, captcha_id, captcha_text

def validate_captcha(captcha_text: str, captcha_id: str) -> int:
    """
    验证验证码是否正确。

    参数:
        captcha_text (str): 用户输入的验证码文本。
        captcha_id (str): 验证码ID。

    返回:
        int: 0表示正确，1表示错误，2表示过期，-1表示格式错误。
    """
    try:
        captcha_token = decrypt(captcha_id)
    except:
        return -1
    try:
        captcha_data = json.loads(captcha_token)
        captcha_expiration = captcha_data.get('captcha_expiration')
        captcha_right_text = captcha_data.get('captcha_text')
    except:
        return -1
    if captcha_expiration < time.time():
        return 2
    elif captcha_text.upper() != captcha_right_text.upper():
        return 1
    else:
        return 0

def validate_json(func):
    """
    验证请求体是否为有效的JSON格式的装饰器。

    该装饰器用于确保传入的HTTP请求包含有效的JSON数据。
    如果请求体不是JSON格式，将返回相应的错误响应。

    参数:
        func (function): 被装饰的函数。

    返回:
        function: 包装后的函数，增加了JSON验证功能。
    """
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            data = request.get_json()
            if not data:
                return jsonify({
                    'code': 400, 'success': False, 'message': '请求体必须为 JSON 格式'
                })
        except:
            return jsonify({
                'code': 400, 'success': False, 'message': 'JSON 解析失败'
            })
        kwargs['data'] = data
        try:
            return func(*args, **kwargs)
        except Exception as e:
            app.logger.error(f"后端服务器方法出错: {str(e)}")
            return jsonify(code=504, message="后端服务器方法出错" + str(e)), 504
    return wrapper

def verify_token(func):
    """
    验证用户令牌。

    该装饰器用于验证用户提供的令牌是否正确。

    并将令牌以形参返回给方法

    参数:
        func (function): 被装饰的函数。

    返回:
        function: 包装后的函数，增加了用户验证功能。
    """
    @wraps(func)
    @jwt_required()
    def wrapper(*args, **kwargs):
        userid_str = 'no info'
        try:
            # 直接获取 sub 字段的值（字符串类型）
            userid_str = get_jwt_identity()

            # 转换为整数
            userid = int(userid_str)
            kwargs['userid'] = userid

            try:
                return func(*args, **kwargs)
            except Exception as e:
                app.logger.error(f"后端服务器方法出错: {str(e)}")
                return jsonify(code=504, message="后端服务器方法出错" + str(e)), 504

        except (ValueError, TypeError) as e:
            app.logger.error(f"用户ID格式错误: {userid_str}")
            return jsonify(code=401, message="无效的用户标识"), 401
        except Exception as e:
            app.logger.error(f"令牌解析异常: {str(e)}")
            return jsonify(code=401, message="令牌验证失败"), 401
    return wrapper

def verify_permissions(permissons:list[str]):
    def actual_decorator(func):  # 中间层接收被装饰函数
        @wraps(func)  # 保留原函数元信息
        def wrapper(*args, **kwargs):  # 内层实现装饰逻辑
            try:
                user_id = kwargs['userid']
            except:
                return jsonify({
                    "code": 401,
                    "msg": "验证权限时缺少用户账号"
                }), 401
            user_level = user.get_user_privilege(user_id)
            if user_level is None:
                return jsonify({
                    "code": 501,
                    "msg": "验证权限时缺少用户等级"
                }), 501
            for p in permissons:
                quanxiandengji = permission.search_privilegelevel_by_name(p)
                if quanxiandengji is None:
                    return jsonify({
                        "code": 501,
                        "msg": "验证权限时缺少权限等级"
                    }), 501
                elif quanxiandengji < 0:
                    return jsonify({
                        "code": 501,
                        "msg": "验证权限时无法查询到该权限的等级"
                    }), 501
                elif user_level < quanxiandengji:
                    return jsonify({
                        "code": 401,
                        "msg": "用户权限等级不足"
                    }), 401
            permission_ids = []
            for p in permissons:
                permission_id = permission.search_permissionid_by_name(p)
                if not permission_id:
                    return jsonify({
                        "code": 501,
                        "message": "验证权限时出错"
                    }), 501
                if permission_id < 0:
                    return jsonify({
                        "code": 501,
                        "message": "验证权限时缺少权限"
                    }), 501
                elif permission_id >= 0 :
                    permission_ids.append(permission_id)
            for permission_id in permission_ids:
                yonghuquanxian = user_permission.search_user_permission(user_id, permission_id)
                if yonghuquanxian is None:
                    return jsonify({
                        "code": 501,
                        "message": "验证权限时出错"

                    },501)
                elif yonghuquanxian == False:
                    return jsonify({
                        "code": 401,
                        "message": "验证权限时缺少权限"
                    }), 401

            try:
                return func(*args, **kwargs)
            except Exception as e:
                app.logger.error(f"后端服务器方法出错: {str(e)}")
                return jsonify(code=504, message="后端服务器方法出错" + str(e)), 504
        return wrapper
    return actual_decorator

@jwt.expired_token_loader
def handle_expired_token(jwt_header, jwt_payload):
    return jsonify({
        "code": 401,
        "msg": "Token已过期，请重新登录"
    }), 401

@jwt.invalid_token_loader
def handle_invalid_token(error_string):
    return jsonify({
        "code": 401,
        "msg": "无效的令牌"
    }), 401

@jwt.unauthorized_loader
def handle_missing_token(error_string):
    return jsonify({
        "code": 401,
        "msg": "请求未携带授权令牌"
    }), 401


@app.route("/", methods=['GET'])
def index():
    """
    返回首页HTML内容。

    返回:
        str: 首页HTML内容。
    """
    with open('index.html', 'r', encoding='utf-8') as f:
        return f.read()

@app.route("/hello_world/", methods=['POST', 'GET'])
def hello_world():
    """
    处理简单的Hello World请求。

    如果请求方法为POST且包含'value'字段，则返回包含该值的问候语；
    否则返回默认的"Hello, World!"。

    参数:
        value (str, 可选): POST请求中传递的值。

    返回:
        str: 问候语或默认消息。
    """
    if request.method == 'POST':
        data = request.get_json()
        if data and 'value' in data:
            return f'Hello, {data["value"]}'
    return "Hello, World!"

@app.route("/api/verify_user/", methods=['POST'])
@verify_token
def verify_user_route(userid):
    """
    验证用户身份接口。

    返回模板:
    成功:
    {
        "code": 200,
        "message": "用户已验证"
    }
    失败:
    {
        "code": 401,
        "message": "未授权"
    }
    """

    app.logger.info(f"用户 {userid} 已验证")
    return jsonify({'code': 200, 'message': '用户已验证'}), 200

@app.route('/api/login/', methods=['POST'])
@validate_json
def login(data):
    """
    用户登录接口。

    请求模板:
    {
        "id": "用户账号",
        "email": "用户邮箱",
        "name": "用户名",
        (以上3个只要一个，若有多个则id>email>name)

        "password": "密码",
        "captcha": "验证码",
        "captcha_id": "验证码ID"
    }

    返回模板:
    成功:
    {
        "code": 200,
        "token": "访问令牌",
        "expires_in": 令牌有效期（秒）
    }
    失败:
    {
        "code": 400,
        "message": "错误信息"
    }
    """
    try:
        app.logger.info(f"登录请求: {data}")

        # 使用 check_all_required_fields 校验必要字段
        required_fields = ['password', 'captcha', 'captcha_id']
        if not check_all_required_fields(data, required_fields):
            missing = [f for f in required_fields if f not in data]
            return jsonify({'code':400,'message':f'缺少必要字段: {",".join(missing)}'}),400

        # 使用 get_priority_key_value 处理优先级字段
        key_value = get_priority_key_value(data, ['id','email','name'])
        if not key_value:
            return jsonify({'code':400,'message':'以下字段至少有一个: id/email/name'}),400
        key, value = key_value

        # 统一处理用户标识逻辑
        user_id = None
        if key == 'id':
            try: user_id = int(value)
            except: return jsonify({'code':400,'message':'用户ID格式错误'}),400
            if not user.search_user_by_id(user_id):
                return jsonify({'code':404,'message':'用户不存在'}),404
        elif key == 'email':
            user_id = user.search_user_by_email(value)
            if not user_id: return jsonify({'code':404,'message':'用户不存在'}),404
        elif key == 'name':
            user_id = user.search_user_by_name(value)
            if not user_id: return jsonify({'code':404,'message':'用户不存在'}),404

        # ==== 验证码验证 ====
        yanzhengjieguo = validate_captcha(data['captcha'], data['captcha_id'])
        if yanzhengjieguo != 0:
            app.logger.warning("验证码验证失败")
            return jsonify({'code': 400, 'message': '验证码错误'}),401

        app.logger.info("验证码验证通过")

        # ==== 用户验证 ====
        password = data.get('password', '').strip()  # 去掉头尾空格
        hashed_password = hashlib.sha256(password.encode()).hexdigest()

        app.logger.info(f"账号: {user_id}, 哈希密码: {hashed_password}")

        if user.user_islocked(user_id):
            app.logger.warning(f"用户被锁定: {user_id}")
            return jsonify({'code': 401, 'message': '用户被锁定'}), 401

        verify_result = user.verify_id_and_password(
            id=user_id,
            password_sha256=hashed_password
        )

        if verify_result == 1:
            app.logger.warning(f"用户不存在: {user_id}")
            return jsonify({'code': 404, 'message': '用户不存在'}), 404
        elif verify_result == 2:
            app.logger.warning(f"密码错误: {user_id}")
            failed_attempts = user.get_user_failed_attempts(user_id)
            user.set_user_failed_attempts(user_id, failed_attempts+1)
            failed_attempts+=1
            if failed_attempts >= settings.login_try_times:
                user.lock_user(user_id)
                return jsonify({'code': 401, 'message': '连续输入错误密码，用户被锁定'}), 401
            return jsonify({'code': 401, 'message': '密码错误'}), 401

        app.logger.info("用户验证通过")
        user.set_user_failed_attempts(user_id, 0)

        # ==== 生成令牌 ====
        token = create_access_token(identity=str(user_id))

        app.logger.debug(f"生成令牌详情: {str(token)}")
        app.logger.info(f"用户 {user_id} 登录成功")

        return jsonify({
            'code': 200,
            'token': token,
            'expires_in': 86400
        })

    except Exception as e:
        app.logger.error(f"登录异常: {str(e)}", exc_info=True)
        return jsonify({'code': 500, 'message': '服务器错误'}), 500

@app.route('/api/captcha/', methods=['GET'])
def get_captcha():
    """
    获取验证码接口。

    返回模板:
    成功:
    {
        "code": 200,
        "data": {
            "image": "验证码图片的Base64编码",
            "captcha_id": "验证码ID"
        }
    }
    """
    captcha_image, captcha_id, captcha_text = generate_captcha()
    return jsonify({
        'code': 200,
        'data': {
            'image': f'data:image/png;base64,{captcha_image}',
            'captcha_id': captcha_id
        }
    })


@app.route("/api/register/", methods=['POST'])
@validate_json
def register(data):
    """
    用户注册接口（增强版）
    请求参数：
    {
        "username": "用户名",
        "email": "邮箱",
        "password": "密码",
        "captcha": "验证码",
        "captcha_id": "验证码ID"
    }

    返回模板:
    成功:
    {
        "code": 201,
        "success": true,
        "message": "注册成功",
        "data": {
            "id": 用户ID
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """

    # 使用 check_all_required_fields 优化字段校验
    required_fields = ['username','email','password','captcha','captcha_id']
    if not check_all_required_fields(data, required_fields):
        missing = [f for f in required_fields if f not in data]
        return jsonify(code=400,success=False,message=f"缺少必要字段: {','.join(missing)}"),400

    # ==== 验证码验证 ====

    yanzhengjieguo = validate_captcha(data['captcha'], data['captcha_id'])
    if yanzhengjieguo != 0:
        app.logger.warning("验证码验证失败")
        return jsonify({'code': 400, 'message': '验证码错误'})

    app.logger.info("验证码验证通过")

    # 邮箱格式校验
    if not re.match(r'^[\w\.-]+@[\w\.-]+\.\w+$', data['email']):
        return jsonify({'code': 400, 'message': '邮箱格式不正确'}), 400

    # 检查邮箱是否已注册
    if user.search_user_by_email(data['email'])>0:
        return jsonify({'code': 408, 'message': '该邮箱已被注册'}), 408


    # 检查用户名是否已注册
    if user.search_user_by_name(data['username'])>0:
        return jsonify({'code': 409, 'message': '该用户名已被注册'}), 409

    try:


        # 创建用户对象
        new_user = User(
            name=data['username'],
            email=data['email'],
            password=data['password']
        )

        # 数据库操作
        user_id = user.register(new_user)
        if not user_id:
            return jsonify({'code': 500, 'message': '用户注册失败'}), 500
        userpermission=user_permission.reset_user_permissions(user_id)
        if not userpermission:
            return jsonify({'code': 500, 'message': '用户权限重置失败'}), 500
        return jsonify({
            'code': 201,
            'success': True,
            'message': '注册成功',
            'data': {'id': user_id}
        }), 201

    except Exception as e:
        app.logger.error(f"注册异常: {str(e)}", exc_info=True)
        return jsonify({'code': 500, 'message': '服务器内部错误'}), 500


@app.route("/captcha/email/")
def get_email_captcha():
    try:
        # 获取邮箱参数
        email = request.args.get("email")
        print(f"Received request for email: {email}")
        if not email:
            return jsonify({"code": 400, "message": "请提供邮箱地址", "data": None}), 400
        
        # 检查邮箱是否存在于userinfo表
        user_id = user.search_user_by_email(email)
        
        if user_id is None:
            return jsonify({"code": 500, "message": "数据库查询失败", "data": None}), 500
        elif user_id == -1:
            return jsonify({"code": 400, "message": "该邮箱未被注册过！", "data": None}), 400

        # 生成验证码
        source = string.digits * 4
        captcha = random.sample(source, 4)
        captcha = "".join(captcha)
        expires_at = int(time.time())+300  # 5分钟后过期

        # 发送邮件
        message = Message(subject="名片册系统新验证码", recipients=[email], body=f"亲爱的用户您好，\n\n您的验证码是:{captcha}\n\n请在5分钟内及时在系统内填写该验证码，否则该验证码将会失效。")
        mail.send(message)
        try:
            if emailcaptcha.insert_email_captcha(email, captcha, expires_at) is not None:
                # 返回成功响应
                # return jsonify({"code": 200, "message": "验证码已发送", "data": None})
                return jsonify({"code": 200, "data": None})
            else:
                 return jsonify({"code": 500, "message": "验证码插入数据库失败", "data": None}), 500
        except  Exception as e:
            return jsonify({"code": 500, "message": "验证码发送失败", "data": str(e)}), 500


    except Exception as e:
        # 返回错误响应
        return jsonify({"code": 500, "message": str(e), "data": None}), 500

@app.route('/change_password/username/', methods=['POST'])
def get_username():
    data = request.get_json()
    email = data.get('email')
    if not email:
        return jsonify({"code": 400, "message": "缺少必要的邮箱参数"}), 400

    user_id = user.search_user_by_email(email)
    if user_id is None:
         return jsonify({"code": 500, "message": "数据库出错"}), 500
    elif user_id == -1:
        return jsonify({"code": 404, "message": "未找到对应的用户"}), 404
    username = user.get_userinfo(user_id, ['name'])
    if username:
         return jsonify({"code": 200, "message": "", "username": username['name']})
    elif username is []:
        return jsonify({"code": 404, "message": "未找到对应的用户"}), 404
    else:
         return jsonify({"code": 500, "message": "数据库出错"}), 500


    # try:
    #     # 连接到 SQLite 数据库
    #     conn = sqlite3.connect('data.db')
    #     cursor = conn.cursor()
    #
    #     # 执行查询
    #     cursor.execute("SELECT name FROM userinfo WHERE email =?", (email,))
    #     result = cursor.fetchone()
    #
    #     if result:
    #         username = result[0]
    #         return jsonify({"code": 200, "message": "", "username": username})
    #     else:
    #         return jsonify({"code": 404, "message": "未找到对应的用户名"}), 404
    #
    # except Exception as e:
    #     return jsonify({"code": 500, "message": str(e)}), 500
    # finally:
    #     if conn:
    #         conn.close()

# @app.route("/change_password/have_verification_code/", methods=['POST'])
@app.route("/change_password/captcha/verify/", methods=['POST'])
def change_password():
    """
    验证验证码并修改密码。

    请求模板:
    {
        "id": 用户ID,
        "captcha": "验证码",
        "password": "新密码"
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "修改密码成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """


    # 修改密码逻辑
    data = request.get_json()
    if data is None:
        return jsonify({'code': 400, 'success': False, 'message': '请求数据不是有效的 JSON 格式'})

    print(f"data：{data}")

    # 必须提供email字段
    email = data.get('email')
    if not email:
        return jsonify({'code': 400, 'success': False, 'message': '必须提供邮箱地址'})

    # 根据email查找用户
    user_id = user.search_user_by_email(email)
    if not user_id:
        return jsonify({'code': 400, 'success': False, 'message': '该邮箱未注册'})

    print(f"user_id:{user_id}")

    # 验证码验证
    stored_code = emailcaptcha.search_captcha(email)

    # 打印用户输入的验证码和从数据库中获取的验证码
    print(f"用户输入的验证码: {data.get('emailVerificationCode')}")
    print(f"数据库中的验证码: {stored_code['captcha']}")

    if not stored_code:
        return jsonify({'code': 400, 'success': False, 'message': '请先获取验证码'})

    # 检查验证码是否匹配（通过列名访问）
    if stored_code['captcha'] != data.get('emailVerificationCode'):
        return jsonify({'code': 400, 'success': False, 'message': '验证码错误'})

    # 检查验证码是否过期
    expires_at = stored_code['expires_at']
    if expires_at < int(time.time()):
        return jsonify({'code': 400, 'success': False, 'message': '验证码已过期'})

    # 密码验证
    new_password = data.get('newPassword')
    if not new_password:
        return jsonify({'code': 400, 'success': False, 'message': '请输入新密码'})

    hashed_pwd = hashlib.sha256(new_password.encode()).hexdigest()
    print(f"hashed_pwd ：{hashed_pwd}")

    if user.verify_id_and_password(user_id, hashed_pwd) == 0:
        return jsonify({'code': 400, 'success': False, 'message': '新密码不能与原密码相同'})
    # 执行密码修改
    if user.change_password(user_id, hashed_pwd):
        emailcaptcha.set_a_captcha_as_used(email)
        return jsonify({'code': 200, 'success': True, 'message': '密码修改成功'})
    else:
        return jsonify({'code': 500, 'success': False, 'message': '密码修改失败'})


@app.route("/verify/", methods=['POST'])
# @validate_json
@verify_token
def verify_account(userid):
    """
    验证用户账号。

    请求模板:
    {

    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "验证成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    return jsonify({'code': 204, 'success': True, 'message': '验证成功'})

#查找替换中的查找功能
@app.route("/namecard/search/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['查询名片'])
def search_namecards(userid, data):
    """
    关键词条件查找名片信息。

    请求格式:
    {
        "holderid": 名片夹ID,
        "keyword": "查找关键词",
        "fields": ["name", "sex", "phone", ...]
    }
    """
    holderid = data.get('holderid')
    keyword = data.get('keyword', '').strip()
    fields = data.get('fields', [])

    if not holderid or not keyword or not fields:
        return jsonify({'code': 400, 'success': False, 'message': '参数不完整'})

    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})

    if namecardholder.search_1_holder_from_id(userid, holderid) is None:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹不存在'})

    results = namecard.search_namecards_by_fields(holderid, keyword, fields)
    if results is not None:
        return jsonify({
            'code': 200,
            'success': True,
            'message': '名片查找成功',
            'data': results
        })

    return jsonify({'code': 500, 'success': False, 'message': '名片查找失败'})

@app.route("/userinfo/search/", methods=['POST'])
@validate_json
@verify_token
def search_userinfo(userid, data):
    """
    查询用户信息。

    请求模板:
    {
        "userinfolist": ["字段1", "字段2", ...]
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问用户信息成功",
        "data": {
            "字段1": "值1",
            "字段2": "值2",
            ...
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    # 使用 check_all_required_fields 校验必要字段
    if not check_all_required_fields(data, ['userinfolist']):
        return jsonify({'code':400,'success':False,'message':'缺少用户信息字段'})

    userinfolist = data.get('userinfolist')
    try:
        for i in range(len(userinfolist)):
            if userinfolist[i] not in user.get_userinfo_key_list():
                return jsonify({
                    'code': 400, 'success': False, 'message': '用户信息字段错误'
                })
        userinfo = user.get_userinfo(userid, userinfolist)
        if userinfo:
            response = {
                'code': 200, 'success': True, 'message': '访问用户信息成功', 'data': userinfo
            }
        else:
            response = {
                'code': 400, 'success': False, 'message': '用户信息不存在'
            }
    except Exception as e:
        print(f"Search userinfo error: {str(e)}")
        response = {
            'code': 500, 'success': False, 'message': '未知异常'
        }
        return jsonify(response)
    return jsonify(response)

@app.route("/holder/search/all/", methods=['POST'])
# @validate_json
@verify_token
@verify_permissions(['查询名片夹'])
def search_all_holder(userid):
    """
    查询所有名片夹信息。

    请求模板:
    {

    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问名片夹列表成功",
        "data": {
            "holder": [
                {"id": 名片夹ID, "name": "名片夹名称"},
                ...
            ]
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    all_holder = namecardholder.search_all_holder(userid)
    if all_holder is None:
        return jsonify({
            'code': 500, 'success': False, 'message': '数据库出错'
        })
    # holders = []
    # for holder in all_holder:
    #     holders.append(holder.to_dict())
    return jsonify({'code': 200, 'success': True, 'message': '访问名片夹列表成功', 'data': {'holder': all_holder}})

# 查询所有回收站名片夹信息
@app.route("/holder/recycle/search/all/", methods=['POST'])
@verify_token  # 用于验证请求的Token，确保用户身份合法
@verify_permissions(['查询名片夹'])
def search_all_recycle_holder(userid):
    """
    查询回收站中的所有名片夹信息。
    请求模板:
    {
        // 请求体为空，可能会由前端直接发送POST请求，无需附加数据
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问回收站名片夹列表成功",
        "data": {
            "holder": [
                {"name": 名片夹名字, "type": 名片夹类型，"source": 名片夹归属,
                 "userName": 账户名，"num": 内容数量, "recycleTime": 删除时间，
                 "createTime": 创建时间，“id”：名片夹id}，
                ...
            ]
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    # 初始化响应模板，默认是失败的状态
    response = {
        'code': 500,
        'success': False,
        'message': '未知异常'  # 如果发生异常，返回这个错误信息
    }

    # 调用数据库查询函数，获取所有回收站中的名片夹信息
    all_holder = namecardholderrecycle.search_all_recycle_holder(userid)

    # 打印用户ID和查询结果，方便调试
    print("请求用户ID:", userid)
    print("数据库查询结果:", all_holder)


    # 如果数据库返回的结果为空，说明查询失败
    if all_holder is None:
        # 返回500错误，提示数据库出错
        return jsonify({
            'code': 500,
            'success': False,
            'message': '数据库出错'
        })

    # 返回成功的响应，包括查询到的名片夹信息
    return jsonify({
        'code': 200,
        'success': True,
        'message': '访问回收站名片夹列表成功',
        'data': {'holder': all_holder}  # 名片夹信息封装在data字段中的holder列表中
    })

@app.route("/holder/recycle/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['删除名片夹'])
def recycle_1_holder(userid, data):
    """
    将单个名片夹移入回收站。

    请求模板:
    {
        ,
        "holderid": 名片夹ID
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "名片夹移入回收站成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    holderid = data.get('holderid')
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID不是数字'})
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    if not namecardholder.search_1_holder_from_id(userid, holderid):
        return jsonify({'code': 400, 'success': False, 'message': '名片夹不存在'})
    huishoujieguo = namecardholderrecycle.insert_1_namecardholderrecycle(holderid)
    if huishoujieguo > 0:
        return jsonify({'code': 204, 'success': True, 'message': '名片夹移入回收站成功'})
    elif  huishoujieguo is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify({'code': 500, 'success': False, 'message': '未知错误'})

@app.route("/holder/restore/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['修改名片夹'])
def restore_1_holder(userid, data):
    """
    将单个名片夹移出回收站。

    请求模板:
    {
        "holderid": 名片夹ID
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "名片夹移出回收站成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    holderid = data.get('holderid')
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID不是数字'})
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    if namecardholder.search_1_holder_from_id(userid, holderid):
        return jsonify({'code': 400, 'success': False, 'message': '名片夹不在回收站中'})
    huishoujieguo = namecardholderrecycle.restore_1_namecardholderrecycle(holderid)
    if huishoujieguo == 0:
        return jsonify({'code': 204, 'success': True, 'message': '名片夹移出回收站成功'})
    elif  huishoujieguo is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify({'code': 500, 'success': False, 'message': '未知错误'})

@app.route("/holder/create/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['插入名片夹'])
def create_1_holder(userid, data):
    """
    创建单个名片夹。

    请求模板:
    {
        "holdername": "名片夹名称"
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "名片夹创建成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    # 使用 get_priority_key_value 获取 holdername
    key_value = get_priority_key_value(data, ['holdername'])
    if not key_value:
        return jsonify({'code':400,'success':False,'message':'缺少holdername字段'})
    _, holdername = key_value

    if not holdername:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹名字段'})
    if namecardholder.search_1_holder_from_name(userid, holdername) > 0:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹已存在'})
    charujiaguo = namecardholder.insert_1_namecardholder(NameCardHolder(name=holdername, user_id=userid))
    if charujiaguo is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    elif charujiaguo > 0:
        return jsonify({'code': 204, 'success': True, 'message': '名片夹创建成功'})
    return jsonify(response)

@app.route("/holder/rename/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['修改名片夹'])
def rename_1_holder(userid, data):
    """
    重命名单个名片夹。

    请求模板:
    {
        "oldholdername": "旧名片夹名称",
        "newholdername": "新名片夹名称"
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "名片夹重命名成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    oldholdername = data.get('oldholdername')
    if not oldholdername:
        return jsonify({'code': 400, 'success': False, 'message': '缺少旧名片夹名字段'})
    oldholderid = namecardholder.search_1_holder_from_name(userid, oldholdername)
    if oldholderid is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    elif namecardholder.search_1_holder_from_name(userid, oldholdername) == -1:
        return jsonify({'code': 400, 'success': False, 'message': '未找到旧名片夹'})
    newholdername = data.get('newholdername')
    if not newholdername:
        return jsonify({'code': 400, 'success': False, 'message': '缺少新名片夹名字段'})
    searchnewholder = namecardholder.search_1_holder_from_name(userid, newholdername)
    if searchnewholder is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    elif searchnewholder > 0:
        return jsonify({'code': 400, 'success': False, 'message': '已存在与新名字的同名名片夹'})
    newholder = NameCardHolder(name=newholdername,id=oldholderid)
    xiugaijieguo = namecardholder.update_1_namecardholder(newholder)
    if xiugaijieguo == 0:
        return jsonify({'code': 204, 'success': True, 'message': '名片夹重命名成功'})
    elif xiugaijieguo == -1:
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})
    elif xiugaijieguo == -2:
        return jsonify({'code': 400, 'success': False, 'message': '用户没有此名片夹'})
    elif xiugaijieguo is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify(response)

@app.route("/holder/delete/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['删除名片夹'])
def delete_1_holder(userid, data):
    """
    删除单个名片夹。

    请求模板:
    {
        "holderid": 名片夹ID
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "名片夹删除成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    holderid = data.get('holderid')
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    if not namecardholder.search_1_holder_from_id(userid, holderid):
        if not namecardholder.search_1_holder_from_id(userid, holderid, isinrecycle=True):
            return jsonify({'code': 400, 'success': False, 'message': '名片夹不存在'})
    shanchujieguo = namecardholder.delete_1_holder(holderid)
    if shanchujieguo == 0:
        return jsonify({'code': 204, 'success': True, 'message': '名片夹删除成功'})
    elif shanchujieguo is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify({'code': 500, 'success': False, 'message': '未知错误'})


@app.route("/namecard/insert/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['插入名片'])
def insert_1_namecard(userid, data):
    """
    插入单张名片。

    请求模板:
    {
        "holderid": 名片夹ID,
        "namecard": {
            "name": "姓名",
            "institution": "机构名称",
            "position": "职位",
            "sex": "性别",
            "phone": "电话",
            "email": "邮箱",
            "address": "地址",
            "weixinid": "微信号",
            "birthday": "出生日期（yyyymmdd）"
        }
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "名片插入成功",
        "data": {
            "cardid": 新增名片ID
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if not namecardholder.search_1_holder_from_id(userid, holderid):
        return jsonify({'code': 400, 'success': False, 'message': '未找到名片夹'})

    namecard_data = data.get('namecard')
    if not namecard_data or not isinstance(namecard_data, dict):
        return jsonify({'code': 400, 'success': False, 'message': '缺少或格式错误的 namecard 字段'})

    name = namecard_data.get('name')
    if not name:
        return jsonify({'code': 400, 'success': False, 'message': '缺少姓名字段'})
    institution = namecard_data.get('institution', '')
    position = namecard_data.get('position', '')
    sex = namecard_data.get('sex', '')
    phone = namecard_data.get('phone', '')
    email = namecard_data.get('email', '')
    address = namecard_data.get('address', '')
    weixinid = namecard_data.get('weixinid', '')
    try:

        birthday = int(namecard_data.get('birthday', 0))
    except:
        return jsonify({
            'code': 400, 'success': False, 'message': '生日格式错误'
        })

    cardid = namecard.insert_1_namecard(NameCard(name=name, institution=institution, position=position,
                                                         sex=sex, phone=phone, email=email, address=address, weixinid=weixinid,birthday=birthday, holder_id=holderid))
    if cardid > 0:
        return jsonify({'code': 200, 'success': True, 'message': '名片插入成功', 'data': {'cardid': cardid}})
    elif cardid is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify(response)

@app.route("/namecard/insert/some/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['插入名片'])
def insert_some_namecard(userid, data):
    """
    插入多张名片。

    请求模板:
    {
        "holderid": 名片夹ID,
        "namecards": [
            {
                "name": "姓名",
                "institution": "机构名称",
                "position": "职位",
                "sex": "性别",
                "phone": "电话",
                "email": "邮箱",
                "address": "地址"
            },
            {
                "name": "姓名",
                "institution": "机构名称",
                "position": "职位",
                "sex": "性别",
                "phone": "电话",
                "email": "邮箱",
                "address": "地址",
                "weixinid": "微信号",
                "birthday": "出生日期（yyyymmdd）"
            },
            ...
        ]
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "名片插入成功",
        "data": {
            "cardnumber": 新增名片的数量
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if not namecardholder.search_1_holder_from_id(userid, holderid) :
        return jsonify({'code': 400, 'success': False, 'message': '未找到名片夹'})

    namecards = []
    for thenamecard in data.get('namecards'):
        namecard_data = thenamecard
        if not namecard_data or not isinstance(namecard_data, dict):
            return jsonify({'code': 400, 'success': False, 'message': '缺少或格式错误的 namecards 字段'})
        name = namecard_data.get('name')
        if not name:
            return jsonify({'code': 400, 'success': False, 'message': '缺少姓名字段'})
        institution = namecard_data.get('institution', '')
        position = namecard_data.get('position', '')
        sex = namecard_data.get('sex', '')
        phone = namecard_data.get('phone', '')
        email = namecard_data.get('email', '')
        address = namecard_data.get('address', '')
        weixinid = namecard_data.get('weixinid', '')
        try:

            birthday = int(namecard_data.get('birthday', 0))
        except:
            return jsonify({
                'code': 400, 'success': False, 'message': '生日格式错误'
            })
        thenamecard = NameCard(holder_id=holderid, name=name, institution=institution, position=position,
                            sex=sex, phone=phone, email=email, address=address, weixinid=weixinid, birthday=birthday)
        namecards.append(thenamecard)

    cardid = namecard.insert_some_namecard(namecards)
    if cardid > 0:
        return jsonify({'code': 200, 'success': True, 'message': '名片插入成功', 'data': {'cardnumber': cardid}})
    elif cardid is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify(response)

@app.route("/namecard/recycle/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['删除名片'])
def recycle_1_namecard(userid, data):
    """
    将单张名片移入回收站。

    请求模板:
    {
        "holderid": 名片夹ID,
        "cardid": 名片ID
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "名片移入回收站成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    holderidcunzai = namecardholder.search_1_holder_from_id(userid, holderid)
    if holderidcunzai is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    elif not holderidcunzai:
        return jsonify({'code': 400, 'success': False, 'message': '用户的回收站外没有此名片夹'})
    cardid = data.get('cardid')
    try:
        cardid = int(cardid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片ID必须为数字'})
    if not cardid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片ID字段'})
    cardidcunzai = namecard.search_some_namecard_from_id_in_holder(holderid, [cardid])
    if cardidcunzai is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    elif not cardidcunzai:
        return jsonify({'code': 400, 'success': False, 'message': '用户的回收站外没有此名片'})
    cardid = namecardrecycle.insert_1_namecardrecycle(cardid)
    if cardid >= 0:
        return jsonify({'code': 204, 'success': True, 'message': '名片移入回收站成功'})
    if cardid is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify(response)

@app.route("/namecard/restore/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['修改名片'])
def restore_1_namecard(userid, data):
    """
    将单张名片移出回收站。

    请求模板:
    {
        "holderid": 名片夹ID,
        "cardid": 名片ID
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "名片移出回收站成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    holderidcunzai = namecardholder.search_1_holder_from_id(userid, holderid)
    if holderidcunzai is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    elif not holderidcunzai:
        return jsonify({'code': 400, 'success': False, 'message': '用户的回收站外没有此名片夹'})
    cardid = data.get('cardid')
    try:
        cardid = int(cardid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片ID必须为数字'})
    if cardid is None:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片ID字段'})
    cardidcunzai = namecard.search_some_namecard_from_id_in_holder(holderid, [cardid], isinrecycle=True)
    if cardidcunzai is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    elif not cardidcunzai:
        return jsonify({'code': 400, 'success': False, 'message': '用户的回收站中没有此名片'})
    cardid = namecardrecycle.restore_1_namecardrecycle(cardid)
    if cardid == 0:
        return jsonify({'code': 204, 'success': True, 'message': '名片移出回收站成功'})
    if cardid is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库出错'})
    return jsonify(response)

@app.route("/namecard/search/all/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['查询名片'])
def search_all_namecard(userid, data):
    """
    查询所有名片信息。

    请求模板:
    {
        "holderid": 名片夹ID
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "名片查询成功",
        "data": [
            {
                "id": 名片ID,
                "name": "姓名",
                "institution": "机构名称",
                "position": "职位",
                "sex": "性别",
                "phone": "电话",
                "email": "邮箱",
                "address": "地址",
                "weixinid": "微信号",
                "birthday": "出生日期（yyyymmdd）"
            },
            ...
        ]
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if namecardholder.search_1_holder_from_id(userid, holderid) is None:
        return jsonify({'code': 400, 'success': False, 'message': '未找到名片夹'})
    jieguo = namecard.search_all_namecard_in_holder(holderid)
    if jieguo is not None:
        return jsonify({'code': 200, 'success': True, 'message': '名片查询成功', 'data': jieguo})
    return jsonify(response)

@app.route("/namecard/search/some/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['查询名片'])
def search_some_namecard(userid, data):
    """
    根据ID列表查询多张名片信息。f

    请求模板:
    {
        "holderid": 名片夹ID,
        "cardids": [名片ID1, 名片ID2, ...]
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "名片查询成功",
        "data": [
            {
                "id": 名片ID,
                "name": "姓名",
                "institution": "机构名称",
                "position": "职位",
                "sex": "性别",
                "phone": "电话",
                "email": "邮箱",
                "address": "地址",
                "weixinid": "微信号",
                "birthday": "出生日期（yyyymmdd）"
            },
            ...
        ]
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if namecardholder.search_1_holder_from_id(userid, holderid) is None:
        return jsonify({'code': 400, 'success': False, 'message': '未找到名片夹'})
    cardids = data.get('cardids', [])
    if len(cardids) == 0:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片id字段'})
    for i in range(len(cardids)):
        try:
            cardids[i] = int(cardids[i])
        except:
            return jsonify({
                'code': 400, 'success': False, 'message': '名片id不是数字'
            })
    jieguo = namecard.search_some_namecard_from_id_in_holder(holderid, cardids)
    if jieguo is not None:
        namecardlist = []
        for i in range(len(jieguo)):
            namecardlist.append(jieguo[i])
        return jsonify({'code': 200, 'success': True, 'message': '名片查询成功', 'data': namecardlist})
    return jsonify(response)

@app.route("/namecard/update/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['修改名片'])
def update_1_namecard(userid, data):
    """
    修改单张名片信息。

    请求模板:
    {
        "holderid": 名片夹ID,
        "namecard": {
            "id": 名片ID,
            "name": "姓名",
            "institution": "机构名称",
            "position": "职位",
            "sex": "性别",
            "phone": "电话",
            "email": "邮箱",
            "address": "地址",
            "weixinid": "微信号",
            "birthday": "出生日期（yyyymmdd）"
        }
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "名片修改成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if namecardholder.search_1_holder_from_id(userid, holderid) is None:
        return jsonify({'code': 400, 'success': False, 'message': '未找到名片夹'})

    namecard_data = data.get('namecard')
    if not namecard_data or not isinstance(namecard_data, dict):
        return jsonify({'code': 400, 'success': False, 'message': '缺少或格式错误的 namecard 字典'})

    cardid = namecard_data.get('id')
    if not cardid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片id字段'})
    try:
        cardid = int(cardid)
    except:
        return jsonify({
            'code': 400, 'success': False, 'message': '名片id不是数字'
        })

    name = namecard_data.get('name')
    if not name:
        return jsonify({'code': 400, 'success': False, 'message': '缺少姓名字段'})
    institution = namecard_data.get('institution', '')
    position = namecard_data.get('position', '')
    sex = namecard_data.get('sex', '')
    phone = namecard_data.get('phone', '')
    email = namecard_data.get('email', '')
    address = namecard_data.get('address', '')
    weixinid = namecard_data.get('weixinid', '')
    try:
        birthday = int(namecard_data.get('birthday', 0))
    except:
        return jsonify({
            'code': 400, 'success': False, 'message': '生日格式错误'
        })

    thenamecard = NameCard(
        id=cardid,
        name=name,
        institution=institution,
        position=position,
        sex=sex,
        phone=phone,
        email=email,
        address=address,
        weixinid=weixinid,
        birthday=birthday,
        holder_id=holderid
    )
    result = namecard.update_1_namecard(thenamecard)
    if result == 0:
        return jsonify({'code': 200, 'success': True, 'message': '名片修改成功'})
    elif result is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库错误'})
    elif result == 1:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹不存在'})
    elif result == 2:
        return jsonify({'code': 400, 'success': False, 'message': '名片不存在'})
    return jsonify(response)

@app.route("/namecard/delete/1/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['删除名片'])
def delete_1_namecard(userid, data):
    """
    删除单张名片。

    请求模板:
    {
        "holderid": 名片夹ID,
        "cardid": 名片ID
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "名片删除成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    response = {
        'code': 500, 'success': False, 'message': '未知异常'
    }
    holderid = data.get('holderid')
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if not holderid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片夹ID字段'})
    try:
        holderid = int(holderid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹ID必须为数字'})
    if namecardholder.search_1_holder_from_id(userid, holderid) is None:
        return jsonify({'code': 400, 'success': False, 'message': '未在回收站外找到名片夹'})
    cardid = data.get('cardid')
    try:
        cardid = int(cardid)
    except:
        return jsonify({'code': 400, 'success': False, 'message': '名片id必须为数字'})
    if not cardid:
        return jsonify({'code': 400, 'success': False, 'message': '缺少名片id字段'})
    try:
        cardid = int(cardid)
    except:
        return jsonify({
            'code': 400, 'success': False, 'message': '名片id不是数字'
        })
    mingpiancunzai = namecard.search_some_namecard_from_id_in_holder(holderid, [cardid])
    if not mingpiancunzai:
        mingpiancunzai = namecard.search_some_namecard_from_id_in_holder(holderid, [cardid], True)
        if not mingpiancunzai:
            return jsonify({'code': 400, 'success': False, 'message': '未找到名片'})

    result = namecard.delete_1_namecard(cardid)
    if result == 0:
        return jsonify({'code': 200, 'success': True, 'message': '名片删除成功'})
    elif result is None:
        return jsonify({'code': 500, 'success': False, 'message': '数据库错误'})
    elif result == -2:
        return jsonify({'code': 400, 'success': False, 'message': '名片夹不存在'})
    elif result == -3:
        return jsonify({'code': 400, 'success': False, 'message': '名片不存在'})
    return jsonify(response)

# 查询所有回收站名片信息
@app.route("/namecard/recycle/search/all/", methods=['POST'])
@verify_token
@verify_permissions(['查询名片'])
def search_all_recycle_namecard(userid):
    """
    查询回收站中的所有名片信息。
    请求模板:
    {
        // 请求体为空，可能会由前端直接发送POST请求，无需附加数据
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问回收站名片列表成功",
        "data": {
            "namecard": [
                {"name": 名片名字, "type": 名片类型，"source": 名片归属,
                 "userName": 账户名，"num": 内容数量, "recycleTime": 删除时间，
                 "createTime": 创建时间，“id”：名片id，“holderId”：所属名片夹id}，
                ...
            ]
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    # 初始化响应模板，默认是失败的状态
    response = {
        'code': 500,
        'success': False,
        'message': '未知异常'  # 如果发生异常，返回这个错误信息
    }

    # 调用数据库查询函数，获取所有回收站中的名片信息
    all_namecard = namecardrecycle.search_all_namecardrecycle_by_user(userid)

    # 打印用户ID和查询结果，方便调试
    print("请求用户ID:", userid)
    print("数据库查询结果:", all_namecard)

    # 如果数据库返回的结果为空，说明查询失败
    if all_namecard is None:
        # 返回500错误，提示数据库出错
        return jsonify({
            'code': 500,
            'success': False,
            'message': '数据库出错'
        })

    # 返回成功的响应，包括查询到的名片信息
    return jsonify({
        'code': 200,
        'success': True,
        'message': '访问回收站名片夹列表成功',
        'data': {'namecard': all_namecard}  # 名片信息封装在data字段中的namecard列表中
    })


@app.route("/add/user/permission/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def add_user_permission(userid,data):
    """
    管理员添加用户权限。

    请求模板:
    {
        "userid0": 普通用户id
        "permission_ids": 权限ID列表
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "添加权限成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    permission_ids = data.get('permission_ids')
    userid0 = data.get('userid0')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})

    # 验证权限
    user_privilege = user.get_user_privilege(userid)
    user_privilege0 = user.get_user_privilege(userid0)
    if user_privilege <= user_privilege0:
        print("本账户权限级别:"+str(user_privilege))
        print("被操作账号权限级别:"+str(user_privilege0))
        print("权限不足，添加权限失败")
        return jsonify({'code': 400, 'success': False, 'message': '权限不足，添加权限失败'})
    for permission_id in permission_ids:
        thislevel =  permission.search_privilegelevel_by_id(permission_id)
        if thislevel >= user_privilege:
            return jsonify({'code': 400, 'success': False, 'message': '你不能为其它用户添加不小于你等级的权限'})
        elif thislevel > user_privilege0:
            return jsonify({'code': 400, 'success': False, 'message': '你不能为其它用户添加大于该用户等级的权限'})

    insert_result = user_permission.insert_user_permissions(userid0, permission_ids)

    if insert_result == 0:
        print("没有权限需要添加")
        return jsonify({'code': 400, 'success': False, 'message': '没有权限需要添加'})
    elif insert_result > 0:
        print(f"成功添加了 {insert_result} 个权限")
        return jsonify({'code': 204, 'success': True, 'message': '添加权限成功'})
    elif insert_result == -1:
        print("添加失败，事务已回滚")
        return jsonify({'code': 500, 'success': False, 'message': '添加权限失败，事务已回滚'})
    else:
        print("发生了未知错误")
        return jsonify({'code': 500, 'success': False, 'message': '添加权限失败，发生了未知错误'})


@app.route("/delete/user/permission/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def delete_user_permission(userid, data):
    """
    管理员删除用户权限。

    请求模板:
    {
        "userid0": 普通用户id
        "permission_ids": 权限ID列表
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "删除权限成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    permission_ids = data.get('permission_ids')
    userid0 = data.get('userid0')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})

    # 验证权限
    user_privilege = user.get_user_privilege(userid)
    user_privilege0 = user.get_user_privilege(userid0)
    if user_privilege <= user_privilege0:
        print("本账户权限级别:"+str(user_privilege))
        print("被操作账号权限级别:"+str(user_privilege0))
        print("权限不足，删除权限失败")
        return jsonify({'code': 400, 'success': False, 'message': '权限不足，删除权限失败'})


    delete_result = user_permission.delete_user_permissions(userid0, permission_ids)

    if delete_result == 0:
        print("没有权限需要删除")
        return jsonify({'code': 400, 'success': False, 'message': '没有权限需要删除'})
    elif delete_result > 0:
        print(f"成功删除了 {delete_result} 个权限")
        return jsonify({'code': 204, 'success': True, 'message': '删除权限成功'})
    elif delete_result == -1:
        print("添加失败，事务已回滚")
        return jsonify({'code': 500, 'success': False, 'message': '删除权限失败，事务已回滚'})
    else:
        print("发生了未知错误")
        return jsonify({'code': 500, 'success': False, 'message': '删除权限失败，发生了未知错误'})

@app.route("/reset/user/permission/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def reset_user_permission(userid, data):
    """
    管理员重置用户权限。

    请求模板:
    {
        "userid0": 普通用户id
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "删除权限成功"
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """
    userid0 = data.get('userid0')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})

    # 验证权限
    user_privilege = user.get_user_privilege(userid)
    user_privilege0 = user.get_user_privilege(userid0)
    if user_privilege <= user_privilege0:
        print("本账户权限级别:"+str(user_privilege))
        print("被操作账号权限级别:"+str(user_privilege0))
        print("权限不足，重置权限失败")
        return jsonify({'code': 400, 'success': False, 'message': '权限不足，重置权限失败'})

    insert_result = user_permission.reset_user_permissions(userid0)

    if insert_result == 0:
        print("重置时添加失败")
        return jsonify({'code': 400, 'success': False, 'message': '重置时添加权限失败'})
    elif insert_result > 0:
        print(f"成功添加了 {insert_result} 个权限")
        return jsonify({'code': 204, 'success': True, 'message': '重置权限成功'})
    elif insert_result == -1:
        print("重置失败，事务已回滚")
        return jsonify({'code': 500, 'success': False, 'message': '重置权限失败，事务已回滚'})
    else:
        print("发生了未知错误")
        return jsonify({'code': 500, 'success': False, 'message': '重置权限失败，发生了未知错误'})


# @app.route("/add/admin/", methods=['POST'])
# @validate_json
# @verify_token
# @verify_permissions(['超级管理员设置管理员权限'])
# def add_admin(userid, data):
#     """
#     添加管理员。
#
#     请求模板:
#     {
#         "userid0": 用户id
#     }
#
#     返回模板:
#     成功:
#     {
#         "code": 204,
#         "success": true,
#         "message": "设置管理员成功"
#     }
#     失败:
#     {
#         "code": 500,
#         "success": false,
#         "message": "错误信息"
#     }
#     """
#     # 验证权限
#     user_privilege = user.get_user_privilege(userid)
#     if user_privilege != 2:
#         print("当前权限级别："+str(user_privilege)+"\n权限不足，管理员设置失败")
#         return jsonify({'code': 500, 'success': False, 'message': '你还不是超级管理员，无权添加管理员'})
#
#     userid0 = data.get('userid0')
#     # 修改权限级别
#     add_result_1 = user.set_user_privilege(userid0, 1)
#     if add_result_1 == False:
#         print("权限级别设置失败")
#         return jsonify({'code': 500, 'success': False, 'message': '权限级别设置失败，发生了未知错误'})
#
#     # 添加管理员权限
#     add_result_2 = user_permission.insert_user_permissions(userid0, [9,10,11,12])
#     if add_result_2 == 0:
#         print("没有权限需要添加")
#         return jsonify({'code': 400, 'success': False, 'message': '没有管理员权限需要添加'})
#     elif add_result_2 > 0:
#         print(f"成功添加了 {add_result_2} 个管理员权限")
#         return jsonify({'code': 204, 'success': True, 'message': '设置管理员成功'})
#     elif add_result_2 == -1:
#         print("添加失败，事务已回滚")
#         return jsonify({'code': 500, 'success': False, 'message': '添加管理员权限失败，事务已回滚'})
#     else:
#         print("发生了未知错误")
#         return jsonify({'code': 500, 'success': False, 'message': '添加管理员权限失败，发生了未知错误'})
#
#
#
# @app.route("/delete/admin/", methods=['POST'])
# @validate_json
# @verify_token
# @verify_permissions(['超级管理员设置管理员权限'])
# def delete_admin(userid, data):
#     """
#     撤销管理员。
#
#     请求模板:
#     {
#         "userid0": 用户id
#     }
#
#     返回模板:
#     成功:
#     {
#         "code": 204,
#         "success": true,
#         "message": "撤销管理员成功"
#     }
#     失败:
#     {
#         "code": 500,
#         "success": false,
#         "message": "错误信息"
#     }
#     """
#     # 验证权限
#     user_privilege = user.get_user_privilege(userid)
#     if user_privilege != 2:
#         print("当前权限级别："+str(user_privilege)+"\n权限不足，管理员撤销失败")
#         return jsonify({'code': 500, 'success': False, 'message': '你还不是超级管理员，无权撤销管理员'})
#
#     userid0 = data.get('userid0')
#     # 修改权限级别
#     delete_result_1 = user.set_user_privilege(userid0, 0)
#     if delete_result_1 == False:
#         print("权限级别设置失败")
#         return jsonify({'code': 500, 'success': False, 'message': '权限级别设置失败，发生了未知错误'})
#
#     # 删除管理员权限
#     delete_result_2 = user_permission.delete_user_permissions(userid0, [9,10,11,12])
#     if delete_result_2 == 0:
#         print("没有权限需要删除")
#         return jsonify({'code': 400, 'success': False, 'message': '没有管理员权限需要删除'})
#     elif delete_result_2 > 0:
#         print(f"成功删除了 {delete_result_2} 个管理员权限")
#         return jsonify({'code': 204, 'success': True, 'message': '撤销管理员成功'})
#     elif delete_result_2 == -1:
#         print("删除失败，事务已回滚")
#         return jsonify({'code': 500, 'success': False, 'message': '撤销管理员权限失败，事务已回滚'})
#     else:
#         print("发生了未知错误")
#         return jsonify({'code': 500, 'success': False, 'message': '撤销管理员权限失败，发生了未知错误'})

@app.route("/user/privilegelevel/set/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['超级管理员设置用户权限等级'])
def set_user_privilegelevel(userid, data):
    """
    超级管理员设置用户权限等级。

    请求模板:
    {
        "userid0": 普通用户id,
        "privilegelevel": 用户权限等级
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问用户权限表成功",
        "data": {
            权限id列表
        }
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    # 使用 check_all_required_fields 优化字段校验
    required_fields = ['userid0', 'privilegelevel']
    if not check_all_required_fields(data, required_fields):
        missing = [f for f in required_fields if f not in data]
        return jsonify(code=400, success=False, message=f"缺少必要字段: {','.join(missing)}"), 400
    userid0 = data.get('userid0')
    privilegelevel = data.get('privilegelevel')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})

    # 验证权限
    user_privilege = user.get_user_privilege(userid)
    user_privilege0 = user.get_user_privilege(userid0)
    if user_privilege <= user_privilege0 or user_privilege <= privilegelevel:
        print("本账户权限级别:" + str(user_privilege))
        print("被操作账号权限级别:" + str(user_privilege0))
        print("要调整到的权限级别:" + str(privilegelevel))
        print("权限不足，设置权限等级失败")
        return jsonify({'code': 400, 'success': False, 'message': '权限不足，设置权限等级失败'})

    set_result = user.set_user_privilege(userid0, privilegelevel)
    if not set_result:
        print("权限级别设置失败")
        return jsonify({'code': 500, 'success': False, 'message': '权限级别设置失败，发生了未知错误'})
    else:
        reset_result = user_permission.reset_user_permissions(userid0)
        if reset_result is None:
            print("权限重置失败")
            return jsonify({'code': 500, 'success': False, 'message': '权限重置失败，发生了未知错误'})
        if reset_result == 0:
            print("权限重置失败")
            return jsonify({'code': 500, 'success': False, 'message': '权限重置失败，未设置新的权限'})
        else:
            print("权限级别设置成功")
            return jsonify({'code': 204, 'success': True, 'message': '权限级别设置成功'})

@app.route("/search/user/permission/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def search_user_permission(userid, data):
    """
    管理员搜索指定用户所有权限。

    请求模板:
    {
        "userid0": 普通用户id
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问用户权限表成功",
        "data": {
            权限id列表
        }
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    userid0 = data.get('userid0')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})

    # 调用数据库查询函数，获取用户所有的权限id列表
    all_permissionid = user_permission.search_user_all_permissions(userid0)

    # 如果数据库返回的结果为空，说明查询失败
    if all_permissionid is None:
        # 返回500错误，提示数据库出错
        return jsonify({
            'code': 500,
            'success': False,
            'message': '数据库出错'
        })

    # 打印用户ID和查询结果，方便调试
    print("请求管理员ID:", userid)
    print("指定用户ID:", userid0)
    print("数据库查询结果:", all_permissionid)

    # 构造成功响应内容，传递 all_permissionid 数据
    response = {
        'code': 200,
        'success': True,
        'message': '访问用户权限表成功',
        'data': all_permissionid
    }
    return jsonify(response)



@app.route("/get/all/permission/", methods=['POST'])
# @validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def get_all_permission(userid):
    """
    获取权限列表。

    请求模板:
    {

    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问权限表成功",
        "data": {
              "permissions": [
                {"name": 权限名字, “id”：权限id}，
                ...
            ]
        }
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    print("获取权限ing")
    # 调用数据库查询函数，获取用户所有的权限id列表
    all_permission = permission.get_all_privilege()

    # 如果数据库返回的结果为空，说明查询失败
    if all_permission is None:
        print("查找结果为空")
        # 返回500错误，提示数据库出错
        return jsonify({
            'code': 500,
            'success': False,
            'message': '数据库出错'
        })

    # 打印ID和查询结果，方便调试
    print("请求管理员ID:", userid)
    print("数据库查询结果:", all_permission)

    # 如果查询到，构造数据列表
    # all_permission_dicts = []
    # for a_permission in all_permission:
    #     # 将每个对象转换为字典格式，并加入到列表中
    #     all_permission_dicts.append(a_permission.to_dict())
    #     print("所有权限:", a_permission.to_dict())

    # 构造成功响应内容，传递数据
    response = {
        'code': 200,
        'success': True,
        'message': '访问权限表成功',
        'data': {'permissions': all_permission}
    }

    return jsonify(response)

######################################################################
@app.route("/api/admin/add/user/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员新增用户'])
def admin_add_user(userid,data):
    """
    管理员新增用户
    请求参数：
    {
        "username": "用户名",
        "email": "邮箱",
        "password": "密码"
    }

    返回模板:
    成功:
    {
        "code": 201,
        "success": true,
        "message": "注册成功",
        "data": {
            "id": 用户ID
        }
    }
    失败:
    {
        "code": 400,
        "success": false,
        "message": "错误信息"
    }
    """

    # 使用 check_all_required_fields 优化字段校验
    required_fields = ['username','email','password']
    if not check_all_required_fields(data, required_fields):
        missing = [f for f in required_fields if f not in data]
        return jsonify(code=400,success=False,message=f"缺少必要字段: {','.join(missing)}"),400

    # 邮箱格式校验
    if not re.match(r'^[\w\.-]+@[\w\.-]+\.\w+$', data['email']):
        return jsonify({'code': 400, 'message': '邮箱格式不正确'}), 400

    # 检查邮箱是否已注册
    if user.search_user_by_email(data['email'])>0:
        return jsonify({'code': 408, 'message': '该邮箱已被注册'}), 408


    # 检查用户名是否已注册
    if user.search_user_by_name(data['username'])>0:
        return jsonify({'code': 409, 'message': '该用户名已被注册'}), 409

    try:


        # 创建用户对象
        new_user = User(
            name=data['username'],
            email=data['email'],
            password=data['password']
        )

        # 数据库操作
        user_id = user.register(new_user)
        if not user_id:
            return jsonify({'code': 500, 'message': '用户注册失败'}), 500
        userpermission=user_permission.reset_user_permissions(user_id)
        if not userpermission:
            return jsonify({'code': 500, 'message': '用户权限重置失败'}), 500
        return jsonify({
            'code': 201,
            'success': True,
            'message': '注册成功',
            'data': {'id': user_id}
        }), 201

    except Exception as e:
        app.logger.error(f"注册异常: {str(e)}", exc_info=True)
        return jsonify({'code': 500, 'message': '服务器内部错误'}), 500

@app.route("/admin/search/userinfo/", methods=['POST'])
@verify_token
@validate_json
@verify_permissions(['管理员查询用户信息'])
def admin_search_userinfo(userid,data):
    """
    查询指定用户信息。
    请求模板:
    {
        userid0:所要查询的用户id
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问用户列表成功",
        "data": {
            "name": 用户名,
            “id”：用户id,
            “email”：用户邮箱,
            "privilegelevel":用户权限等级，
            "password_sha256":用户密码
        }
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    print("查找指定用户信息ing")
    userid0=data.get('userid0')
    # 调用数据库查询函数，获取指定用户信息
    userData = user.get_userinfo_by_id(userid0)
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})

    # 打印用户ID和查询结果，方便调试
    print("请求用户ID:", userid)
    print("数据库查询结果:", userData)

    # 如果数据库返回的结果为空，说明查询失败
    if userData is None:
        # 返回500错误，提示数据库出错
        return jsonify({
            'code': 500,
            'success': False,
            'message': '数据库出错'
        })

    # 返回成功的响应，包括查询到的用户信息
    return jsonify({
        'code': 200,
        'success': True,
        'message': '查找指定用户信息成功',
        'data': userData
    })

@app.route("/get/all/userinfo/", methods=['POST'])
@verify_token
@verify_permissions(['管理员查询用户信息'])
def get_all_userinfo(userid):
    """
    获取所有用户信息。
    请求模板:
    {

    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "访问用户列表成功",
        "data": {
            {"name": 用户名,
            “id”：用户id,
            “email”：用户邮箱,
            "privilegelevel":用户权限等级，
            "password_sha256":用户密码},
            ...
        }
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    # 调用数据库查询函数，获取指定用户信息
    userData = user.get_all_userinfo()

    # 打印用户ID和查询结果，方便调试
    print("请求用户ID:", userid)
    print("数据库查询结果:", userData)

    # 如果数据库返回的结果为空，说明查询失败
    if userData is None:
        # 返回500错误，提示数据库出错
        return jsonify({
            'code': 500,
            'success': False,
            'message': '数据库出错'
        })
    # 返回成功的响应，包括查询到的用户信息
    return jsonify({
        'code': 200,
        'success': True,
        'message': '访问用户列表成功',
        'data': userData
    })

@app.route("/admin/change_password/", methods=['POST'])
@verify_token
@validate_json
@verify_permissions(['管理员重置用户密码'])
def admin_change_password(userid,data):
    """
    管理员重置用户密码。

    请求模板:
    {
        "userid0": 用户ID,
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "重置密码成功"

    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """

    userid0 = data.get('userid0')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})
    # 执行密码修改
    new_password = '88888888'
    # 密码加密
    hashed_pwd = hashlib.sha256(new_password.encode()).hexdigest()
    print(f"hashed_pwd ：{hashed_pwd}")
    if user.change_password(userid0, hashed_pwd):
        print('重置密码成功')
        return jsonify({'code': 200, 'success': True, 'message': '密码重置成功'})
    else:
        print('密码重置失败')
        return jsonify({'code': 500, 'success': False, 'message': '密码重置失败'})

@app.route("/user/lock/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def lockuser(userid, data):
    """
    管理员锁定指定用户。

    请求模板:
    {
        "userid0": 锁定用户id
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "锁定用户成功"
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    if not check_all_required_fields(data, ['userid0']):
        return jsonify({'code': 400, 'success': False, 'message': '请求体缺少必要字段'})
    userid0 = data.get('userid0')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})
    lock_result = user.lock_user(userid0)
    if lock_result is None:
        print("数据库错误")
        return jsonify({'code': 500, 'success': False, 'message': '锁定用户失败，发生了未知错误'})
    elif not lock_result:
        print("锁定用户失败")
        return jsonify({'code': 500, 'success': False, 'message': '锁定用户失败，发生了未知错误'})
    else:
        print("锁定用户成功")
        return jsonify({'code': 204, 'success': True, 'message': '锁定用户成功'})

@app.route("/user/unlock_and_reset_failed_attempts/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def unlockuser(userid, data):
    """
    管理员解锁指定用户并重置登录失败次数。

    请求模板:
    {
        "userid0": 解锁用户id
    }

    返回模板:
    成功:
    {
        "code": 204,
        "success": true,
        "message": "解锁用户成功"
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    if not check_all_required_fields(data, ['userid0']):
        return jsonify({'code': 400, 'success': False, 'message': '请求体缺少必要字段'})
    userid0 = data.get('userid0')
    if not user.search_user_by_id (userid0):
        return jsonify({'code': 400, 'success': False, 'message': '用户不存在'})
    setfailatt = user.set_user_failed_attempts(userid0, 0)
    unlock_result = user.unlock_user(userid0)
    if unlock_result is None or setfailatt is None:
        print("数据库错误")
        return jsonify({'code': 500, 'success': False, 'message': '解锁用户失败，发生了未知错误'})
    elif not unlock_result or not setfailatt:
        print("解锁用户失败")
        return jsonify({'code': 500, 'success': False, 'message': '解锁用户失败，发生了未知错误'})
    else:
        print("解锁用户成功")
        return jsonify({'code': 204, 'success': True, 'message': '解锁用户成功'})

@app.route("/get/login_try_times/", methods=['POST'])
# @validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def get_login_try_times(userid):
    """
    管理员获取系统允许的登录错误次数
    请求模板:
    {

    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "获取系统允许的登录错误次数成功",
        "data": 次数
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    cishu = settings.login_try_times
    return jsonify({
        'code': 200,
        'success': True,
        'message': '获取系统允许的登录错误次数成功',
        'data': cishu
    })


@app.route("/set/login_try_times/", methods=['POST'])
@validate_json
@verify_token
@verify_permissions(['管理员设置用户权限'])
def set_login_try_times(userid, data):
    """
    管理员设置系统允许的登录错误次数
    请求模板:
    {
        "login_try_times": 次数
    }

    返回模板:
    成功:
    {
        "code": 200,
        "success": true,
        "message": "获取系统允许的登录错误次数成功",
        "data": 次数
    }
    失败:
    {
        "code": 500,
        "success": false,
        "message": "错误信息"
    }
    """
    check_all_required_fields(data, ['login_try_times'])
    cishu = data.get('login_try_times')
    try:
        cishu = int(cishu)
        if cishu < 0:
            return jsonify({
                'code': 400,
                'success': False,
                'message': '设置系统允许的登录错误次数失败，传入字段小于0'
            })

        settings.login_try_times = cishu
        return jsonify({
            'code': 204,
            'success': True,
            'message': '设置系统允许的登录错误次数成功',
        })
    except ValueError:
        return jsonify({
            'code': 400,
            'success': False,
            'message': '设置系统允许的登录错误次数失败，传入字段不是数字'
        })

if __name__ == '__main__':
    app.run(debug=settings.debug, host=settings.host, port=settings.port)